/**
 * 教研老师确认学生报名和老师撤销学生报名以及老师删除学生报名
 * 
 * 确认：
 * 1.当前课题确认人数  +1
 * 2.学生选题状态变成老师确认
 * 
 * 撤销： 
 * 1.当前课题确认人数 -1
 * 2.学生选题状态变成已报名
 * 
 * 删除：
 * 1.当前报名人数 -1
 * 学生选题状态变成未报名
 * 
 * /jiaoyan/student/confirm
 */



 

const Topics= require('../../../models/researchTopics')
const Years= require('../../../models/years')
const Topic_Student = require('../../../models/researchTopicStudents')
const MySQLManager = require('../../../utils/MySQLManager');
const sequelize = MySQLManager
const Sequelize = require('sequelize')
const Op = Sequelize.Op
const utils = require('../../../utils/index')
const $ = require('../../../utils/common')

const confirm = async function (req, res) {
    try {
        // 0 撤销 1 确认 2 删除
        var code = ['0', '1', '2']

        // 年度id， 课题id， 学生id， 操作：删除，确认，撤销
        if (!req.body.year_id || !req.body.student_id || !req.body.code || !req.body.topic_id) {
            $.sendMessage(res, 1015, '参数错误')
            return
        }

        if (!code.includes(req.body.code)) {
            $.sendMessage(res, 1015, 'code格式错误')
            return
        }

        // 判断年度是否存在
        var is_year_exist = await Years.findOne({
            where: {
                id: req.body.year_id,
                type: '0'
            }
        })

        if(is_year_exist == null) { 
            $.sendMessage(res, 1015, '无效年度id') 
            return
        }

        // 判断当前题目是否存在
        var is_topic_exist = await Topics.findOne({
            where: {
                id: req.body.topic_id
            }
        })

        if (is_topic_exist == null) {
            $.sendMessage(res, 1015, '无效topic_id')
            return
        }

        // 判断该年度报名该课题的学生是否存在
        var is_student_exist = await Topic_Student.findOne({
            where: {
                id: req.body.student_id,
                topic_id: req.body.topic_id,
                student_year: req.body.year_id,
                student_status: {
                    [Op.or]: ['0', '2']
                }
            }
        })

        if (is_student_exist == null) {
            $.sendMessage(res, 1015, '无效student_id,意思就是没有满足一下逻辑：报名或被确认该题目的属于该年度的学生不存在')
            return
        }

        // 确认学生报名
        if (req.body.code == '1') {
            // 只能确认报名状态下的学生
            if (is_student_exist.dataValues.student_status != '0') {
                $.sendMessage(res, 1015, '只能确认报名状态下的学生')
                return
            }

            // 当前课题确认人数加1但是不可以超过可确认人数， 学生状态变为老师已确认
            // 先判断当前课题确认人数是否已满
            if (is_topic_exist.dataValues.confirm_num >= is_topic_exist.dataValues.student_limit) {
                $.sendMessage(res, 1015, '确认学生人数等于可带学生人数，不能继续确认')
                return
            }

            //  事务
            return sequelize.transaction(function (t) {
                return Topic_Student.update(
                {
                    student_status: '2',
                },
                {
                    where: {
                        student_year: req.body.year_id,
                        topic_id: req.body.topic_id,
                        id: req.body.student_id
                    }
                }
                , 
                {transaction: t}).then(function (user) {
                    return Topics.findOne(
                        {
                            where: {
                                id: req.body.topic_id
                            }
                        }
                        , {transaction: t})
                    }).then( topic => {

                    return topic.increment('confirm_num'
                    ,{transaction: t}).then( () => {
                    })
                    })
                })
                // 请求完整完成
                .then(function (result) {
                    res.json({
                        code: 200,
                        message: '确认成功',
                        result: result
                    })
                    utils.create_a_log(req, '学生入所', '老师确认报名')
                    return
                })
                // 处理sequalize异常
                .catch(function (err) {
                    res.json({
                        code: 1017,
                        message: '失败，请联系管理员',
                        err: 'err' + err
                    })
                    return
                })
        }


        // 撤销确认的学生
        if (req.body.code == '0') {
            // 确认状态下才能撤销
            if (is_student_exist.dataValues.student_status != '2') {
                $.sendMessage(res, 1015, '只能撤销处于确定状态的学生')
                return
            }

            // 当前课题确认人数-1 ， 学生状态该为报名
            //  事务
            return sequelize.transaction(function (t) {
                return Topic_Student.update(
                {
                    student_status: '0',
                },
                {
                    where: {
                        student_year: req.body.year_id,
                        topic_id: req.body.topic_id,
                        id: req.body.student_id
                    }
                }
                , 
                {transaction: t}).then(function (user) {
                    return Topics.findOne(
                        {
                            where: {
                                id: req.body.topic_id
                            }
                        }
                        , {transaction: t})
                    }).then( topic => {

                    return topic.decrement('confirm_num'
                    ,{transaction: t}).then( () => {
                    })
                    })
                })
                // 请求完整完成
                .then(function (result) {
                    res.json({
                        code: 200,
                        message: '撤销确认成功',
                        result: result
                    })
                    utils.create_a_log(req, '学生入所', '老师撤销确认报名')
                    return
                })
                // 处理sequalize异常
                .catch(function (err) {
                    res.json({
                        code: 1017,
                        message: '失败，请联系管理员',
                        err: 'err' + err
                    })
                    return
                })
        }

        // 删除报名的学生
        if (req.body.code == '2') {
            // 报名了才能删除，确认了的话需要先撤销
            if (is_student_exist.dataValues.student_status == '2') {
                $.sendMessage(res, 1015, '只能删除处于报名状态的学生，当前状态是已确认，请撤销后再操作')
                return
            }

            //  当前课题报名人数-1 ， 学生状态为未报名
            //  事务
            return sequelize.transaction(function (t) {
                return Topic_Student.update(
                {
                    topic_id: '',
                    student_status: '1',
                    topic_name: '',
                    teacher_fullname: ''
                },
                {
                    where: {
                        student_year: req.body.year_id,
                        topic_id: req.body.topic_id,
                        id: req.body.student_id
                    }
                }
                , 
                {transaction: t}).then(function (user) {
                return Topics.findOne(
                    {
                        where: {
                            id: req.body.topic_id
                        }
                    }
                    , {transaction: t})
                }).then( topic => {

                return topic.decrement('current_student'
                ,{transaction: t}).then( () => {
                })
                })
            })
            // 请求完整完成
            .then(function (result) {
                res.json({
                    code: 200,
                    message: '删除成功',
                    result: result
                })
                utils.create_a_log(req, '学生入所', '老师删除学生报名')
                return
            })
            // 处理sequalize异常
            .catch(function (err) {
                res.json({
                    code: 1017,
                    message: '失败，请联系管理员',
                    err: 'err' + err
                })
                return
            })
        }

    }
    catch(error) {
        res.json({
            message: "抓到异常",
            error: 'error' + error
        })
        utils.create_a_log(req, '科研题目管理', '确认，撤销，删除学生报名', '失败')
    } 
}
    
module.exports = confirm